home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / circuits / pcb-1.000 / pcb-1 / pcb-1.3 / draw.c < prev    next >
C/C++ Source or Header  |  1995-02-27  |  19KB  |  650 lines
  1. /*
  2.  *                            COPYRIGHT
  3.  *
  4.  *  PCB, interactive printed circuit board design
  5.  *  Copyright (C) 1994,1995 Thomas Nau
  6.  *
  7.  *  This program is free software; you can redistribute it and/or modify
  8.  *  it under the terms of the GNU General Public License as published by
  9.  *  the Free Software Foundation; either version 2 of the License, or
  10.  *  (at your option) any later version.
  11.  *
  12.  *  This program is distributed in the hope that it will be useful,
  13.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  *  GNU General Public License for more details.
  16.  *
  17.  *  You should have received a copy of the GNU General Public License
  18.  *  along with this program; if not, write to the Free Software
  19.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  *
  21.  *  Contact addresses for paper mail and Email:
  22.  *  Thomas Nau, Schlehenweg 15, 88471 Baustetten, Germany
  23.  *  Thomas.Nau@rz.uni-ulm.de
  24.  *
  25.  */
  26.  
  27. static    char    *rcsid = "$Header: /sda6/users/nau/src/pcb/RCS/draw.c,v 2.2 1994/10/03 16:00:05 nau Exp $";
  28.  
  29. /* drawing routines
  30.  */
  31.  
  32. /* ---------------------------------------------------------------------------
  33.  * define TO_SCREEN before macro.h is included from global.h
  34.  */
  35. #define TO_SCREEN(a)    ((a) >> ZoomValue)
  36.  
  37. #include "global.h"
  38.  
  39. #include "crosshair.h"
  40. #include "data.h"
  41. #include "draw.h"
  42. #include "mymem.h"
  43. #include "misc.h"
  44. #include "rotate.h"
  45. #include "select.h"
  46.  
  47. /* ---------------------------------------------------------------------------
  48.  * some local constants
  49.  */
  50. #define    TAN_CONST        0.207106781            /* 0.5*tan(22.5) */
  51.  
  52. /* ---------------------------------------------------------------------------
  53.  * some local types
  54.  */
  55. typedef struct
  56. {
  57.     float    X,
  58.             Y;
  59. } FloatPolyType, *FloatPolyTypePtr;
  60.  
  61. /* ---------------------------------------------------------------------------
  62.  * some local identifiers
  63.  */
  64. static    int                    ZoomValue;        /* zoom and drawable common to */
  65. static    Window                DrawingWindow;    /* all drawing routines */
  66. static    XPoint                Outline[MAX_SIZE+1][8];
  67.  
  68. /* ---------------------------------------------------------------------------
  69.  * some local prototypes
  70.  */
  71. static    void    Redraw(Boolean);
  72. static    void    DrawEverything(void);
  73. static    void    DrawLayer(LayerTypePtr);
  74. static    void    InitSpecialPolygon(void);
  75. static    void    DrawSpecialPolygon(GC, Position, Position, XPoint *);
  76. static    void    DrawPinOrViaLowLevel(PinTypePtr);
  77. static    void    DrawLineLowLevel(LineTypePtr);
  78. static    void    DrawBoxLowLevel(BoxTypePtr);
  79. static    void    DrawTextLowLevel(TextTypePtr);
  80. static    void    DrawPolygonLowLevel(PolygonTypePtr);
  81. static    void    DrawArcLowLevel(ArcTypePtr);
  82. static    void    DrawElementPackageLowLevel(ElementTypePtr Element);
  83.  
  84. /* ---------------------------------------------------------------------------
  85.  * redraws the output area without clearing it
  86.  */
  87. void RedrawOutput(void)
  88. {
  89.     Redraw(False);
  90. }
  91.  
  92. /* ---------------------------------------------------------------------------
  93.  * redraws the output area after clearing it
  94.  */
  95. void ClearAndRedrawOutput(void)
  96. {
  97.     Redraw(True);
  98. }
  99.  
  100. /* ---------------------------------------------------------------------- 
  101.  * redraws all the data
  102.  * all necessary sizes are already set by the viewport widget and
  103.  * by the event handlers
  104.  */
  105. static void Redraw(Boolean ClearWindow)
  106. {
  107.     XEvent    event;
  108.  
  109.         /* check if window already exists */
  110.     if (Output.OutputWindow)
  111.     {
  112.             /* remove all other pending expose events from queue */
  113.         while (XtAppPending(Context))
  114.         {
  115.             XtAppNextEvent(Context, &event);
  116.             if (event.type != Expose ||
  117.                 ((XExposeEvent *) &event)->window != Output.OutputWindow)
  118.                 XtDispatchEvent(&event);
  119.         }
  120.  
  121.             /* switch off crosshair, change drawing window and redraw
  122.              * everything
  123.              */
  124.         HideCrosshair(True);
  125.         SwitchDrawingWindow(PCB->Zoom, Output.OutputWindow);
  126.  
  127.             /* reset the cursor state because of clearing the background
  128.              * of the drawing area
  129.              */
  130.         if (ClearWindow)
  131.         {
  132.             XSetForeground(Dpy, Output.fgGC, Settings.OffLimitColor);
  133.             XFillRectangle(Dpy, DrawingWindow, Output.fgGC,
  134.                 0, 0, MAX_COORD, MAX_COORD);
  135.             XFillRectangle(Dpy, DrawingWindow, Output.bgGC,
  136.                 0, 0, TO_SCREEN(PCB->MaxWidth), TO_SCREEN(PCB->MaxHeight));
  137.             Crosshair.On = False;
  138.         }
  139.  
  140.         DrawEverything();
  141.  
  142.             /* redraw might have come from scrolling the window
  143.              * so we do an update of the cursor position
  144.              */
  145.         MoveCrosshairRelative(0, 0);
  146.         RestoreCrosshair(True);
  147.     }
  148. }
  149.  
  150. /* ----------------------------------------------------------------------
  151.  * setup of zoom and output window for the next drawing operations
  152.  */
  153. void SwitchDrawingWindow(int Zoom, Window OutputWindow)
  154. {
  155.     ZoomValue = Zoom;
  156.     DrawingWindow = OutputWindow;
  157.     InitSpecialPolygon();
  158. }
  159.  
  160. /* ---------------------------------------------------------------------------
  161.  * initializes some identifiers for a new zoom factor and redraws whole screen
  162.  */
  163. static void DrawEverything(void)
  164. {
  165.     Cardinal    i;
  166.  
  167.         /* draw all layers beside the current one */
  168.     for (i = MAX_LAYER-1; i; i--)
  169.         if ((LAYER_ON_STACK(i))->On)
  170.             DrawLayer(LAYER_ON_STACK(i));
  171.  
  172.         /* draw element packages; pins are drawn by RedrawCurrentLayer() */
  173.     if (PCB->ElementOn)
  174.         ELEMENT_LOOP(PCB->Data,
  175.             DrawElementPackage(element);
  176.             DrawElementName(element);
  177.         );
  178.  
  179.         /* make sure that the current layer is always visible */
  180.     RedrawCurrentLayer();
  181.     if (Settings.DrawGrid)
  182.         DrawGrid();
  183. }
  184.  
  185. /* ---------------------------------------------------------------------------
  186.  * redraws the current layer as well as pins and vias
  187.  * the later ones are drawn at last to make the drilling hole visible
  188.  */
  189. void RedrawCurrentLayer(void)
  190. {
  191.     HideCrosshair(True);
  192.     DrawLayer(CURRENT);
  193.  
  194.         /* draw element pins */
  195.     if (PCB->PinOn)
  196.         ELEMENT_LOOP(PCB->Data, DrawElementPins(element););
  197.  
  198.         /* draw vias */
  199.     if (PCB->ViaOn)
  200.         VIA_LOOP(PCB->Data, DrawVia(via););
  201.  
  202.     RestoreCrosshair(True);
  203. }
  204.  
  205. /* ---------------------------------------------------------------------------
  206.  * draws one layer
  207.  */
  208. static void DrawLayer(LayerTypePtr Layer)
  209. {
  210.         /* draw all objects by calling their drawing routines */
  211.     LINE_LOOP(Layer, DrawLine(Layer, line););
  212.     TEXT_LOOP(Layer, DrawText(Layer, text););
  213.     POLYGON_LOOP(Layer, DrawPolygon(Layer, polygon););
  214. } 
  215.  
  216. /* ---------------------------------------------------------------------------
  217.  * initializes some zoom dependend information for pins and lines
  218.  * just to speed up drawing a bit
  219.  */
  220. static void InitSpecialPolygon(void)
  221. {
  222.             int                i, j;
  223.     static    FloatPolyType    p[8] = {{       0.5, -TAN_CONST},
  224.                                     { TAN_CONST,       -0.5},
  225.                                     {-TAN_CONST,       -0.5},
  226.                                     {      -0.5, -TAN_CONST},
  227.                                     {      -0.5,  TAN_CONST},
  228.                                     {-TAN_CONST,        0.5},
  229.                                     { TAN_CONST,        0.5},
  230.                                     {       0.5,  TAN_CONST}};
  231.  
  232.  
  233.         /* loop over maximum number of different sizes */
  234.     for (i = 0; i <= MAX(MAX_PINORVIASIZE, MAX_LINESIZE); i++)
  235.         for (j = 0; j < 8; j++)
  236.         {
  237.             Outline[i][j].x = (p[j].X * TO_SCREEN_X(i));
  238.             Outline[i][j].y = (p[j].Y * TO_SCREEN_Y(i));
  239.         }
  240. }
  241.  
  242. /* ---------------------------------------------------------------------------
  243.  * draws one polygon
  244.  * x and y are already in display coordinates
  245.  * the points are numbered:
  246.  *
  247.  *          5 --- 6
  248.  *         /       \
  249.  *        4         7
  250.  *        |         |
  251.  *        3         0
  252.  *         \       /
  253.  *          2 --- 1
  254.  *
  255.  */
  256. static void DrawSpecialPolygon(GC DrawGC,
  257.     Position X, Position Y, XPoint *PolyPtr)
  258. {
  259.     int        i;
  260.     XPoint    polygon[8];
  261.  
  262.         /* add line offset */
  263.     for (i = 0; i < 8; i++)
  264.     {
  265.         polygon[i].x = X+ PolyPtr[i].x;
  266.         polygon[i].y = Y+ PolyPtr[i].y;
  267.     }
  268.     XFillPolygon(Dpy, DrawingWindow, DrawGC,
  269.         polygon, ENTRIES(polygon), Convex, CoordModeOrigin);
  270. }
  271.  
  272. /* ---------------------------------------------------------------------------
  273.  * lowlevel drawing routine for pins and vias
  274.  */
  275. static void DrawPinOrViaLowLevel(PinTypePtr Ptr)
  276. {
  277.         /* transform X11 specific coord system */
  278.     DrawSpecialPolygon(Output.fgGC, TO_SCREEN_X(Ptr->X), TO_SCREEN_Y(Ptr->Y),
  279.         &Outline[Ptr->Thickness][0]);
  280.     DrawSpecialPolygon(Output.bgGC, TO_SCREEN_X(Ptr->X), TO_SCREEN_Y(Ptr->Y),
  281.         &Outline[Ptr->DrillingHole][0]);
  282. }
  283.  
  284. /* ---------------------------------------------------------------------------
  285.  * lowlevel drawing routine for lines
  286.  */
  287. static void DrawLineLowLevel(LineTypePtr Line)
  288. {
  289.     XSetLineAttributes(Dpy, Output.fgGC,
  290.         TO_SCREEN(Line->Thickness),
  291.         LineSolid, CapRound, JoinRound);
  292.     XDrawLine(Dpy, DrawingWindow, Output.fgGC,
  293.         TO_SCREEN_X(Line->X1), TO_SCREEN_Y(Line->Y1),
  294.         TO_SCREEN_X(Line->X2), TO_SCREEN_Y(Line->Y2));
  295. }
  296.  
  297. /* ---------------------------------------------------------------------------
  298.  * lowlevel drawing routines for boxes
  299.   */
  300. static void DrawBoxLowLevel(BoxTypePtr Box)
  301. {
  302.     Position    x, y;
  303.     Dimension   width, height;
  304.  
  305.         /* convert x and y to window coordinates */
  306.     x = TO_SCREEN_X(Box->X1);
  307.     y = TO_SCREEN_Y(Box->Y1);
  308.     width = TO_SCREEN(Box->X2 -Box->X1);
  309.     height = TO_SCREEN(Box->Y2 -Box->Y1);
  310.     XFillRectangle(Dpy, DrawingWindow, Output.fgGC, x, y, width, height);
  311. }
  312.  
  313. /* ---------------------------------------------------------------------------
  314.  * lowlevel drawing routine for text objects
  315.  */
  316. static void DrawTextLowLevel(TextTypePtr Text)
  317. {
  318.     Position        x = Text->X,
  319.                     y = Text->Y,
  320.                     x0 = 0;            /* initialize to get rid of warnings */
  321.     unsigned char    *string = (unsigned char *) Text->TextString;
  322.     Cardinal        n;
  323.     FontTypePtr        font = &PCB->Font;
  324.  
  325.         /* if text has to be mirrored, get x0 with the unrotated
  326.          * width of the surrounding box (which is the length of the string)
  327.          */
  328.     if (TEST_FLAG(MIRRORFLAG, Text))
  329.     {
  330.         Dimension    width = Text->BoundingBox.X2 -Text->BoundingBox.X1,
  331.                     height = Text->BoundingBox.Y2 -Text->BoundingBox.Y1;
  332.  
  333.         if (Text->Direction == 0 || Text->Direction == 2)
  334.             x0 = Text->X +width/2;
  335.         else
  336.             x0 = Text->X +height/2;
  337.     }
  338.     while (string && *string)
  339.     {
  340.             /* draw lines if symbol is valid and data is present */
  341.         if (*string <= MAX_FONTPOSITION && font->Symbol[*string].Valid)
  342.         {
  343.             LineTypePtr    line = font->Symbol[*string].Line;
  344.             LineType    newline;
  345.  
  346.             for (n = font->Symbol[*string].LineN; n; n--, line++)
  347.             {
  348.                     /* create one line, scale and move it */
  349.                 newline = *line;
  350.                 newline.X1 = newline.X1 *Text->Scale /100 +x;
  351.                 newline.Y1 = newline.Y1 *Text->Scale /100 +y;
  352.                 newline.X2 = newline.X2 *Text->Scale /100 +x;
  353.                 newline.Y2 = newline.Y2 *Text->Scale /100 +y;
  354.                 newline.Thickness = newline.Thickness *Text->Scale /100;
  355.  
  356.                     /* do some mirroring and rotations */
  357.                 if (TEST_FLAG(MIRRORFLAG, Text))
  358.                 {
  359.                     newline.X1 = 2*x0 -newline.X1;
  360.                     newline.X2 = 2*x0 -newline.X2;
  361.                 }
  362.                 RotateLineLowLevel(&newline,Text->X,Text->Y,Text->Direction);
  363.                 DrawLineLowLevel(&newline);
  364.             }
  365.                 /* move on to next cursor position */
  366.             x += ((font->Symbol[*string].Width +font->Symbol[*string].Delta)
  367.                 *Text->Scale /100);
  368.         }
  369.         else
  370.         {
  371.                 /* the default symbol is a filled box */
  372.             BoxType    defaultsymbol = PCB->Font.DefaultSymbol;
  373.  
  374.             defaultsymbol.X1 = defaultsymbol.X1 *Text->Scale /100 +x;
  375.             defaultsymbol.Y1 = defaultsymbol.Y1 *Text->Scale /100 +y;
  376.             
  377.  
  378.                 /* do some mirroring and rotations */
  379.             if (TEST_FLAG(MIRRORFLAG, Text))
  380.                 defaultsymbol.X1 = 2*x0 -defaultsymbol.X1 -defaultsymbol.X2;
  381.             RotateBoxLowLevel(&defaultsymbol,Text->X,Text->Y, Text->Direction);
  382.             DrawBoxLowLevel(&defaultsymbol);
  383.  
  384.                 /* move on to next cursor position */
  385.             x += ((defaultsymbol.X2 -defaultsymbol.X1)/4 *Text->Scale /100);
  386.         }
  387.         string++;
  388.     }
  389. }
  390.  
  391. /* ---------------------------------------------------------------------------
  392.  * lowlevel drawing routine for polygons
  393.  */
  394. static void DrawPolygonLowLevel(PolygonTypePtr Polygon)
  395. {
  396.     static    XPoint        *data = NULL;    /* tmp pointer */
  397.     static    Cardinal    max = 0;
  398.  
  399.         /* allocate memory for data with screen coordinates */
  400.     if (Polygon->PointN > max)
  401.     {
  402.         max = Polygon->PointN;
  403.         data = (XPoint *) MyRealloc(data, max *sizeof(XPoint),
  404.             "DrawPolygonLowLevel()");
  405.     }
  406.  
  407.         /* copy data to tmp array and convert it to screen coordinates */
  408.     POLYGONPOINT_LOOP(Polygon,
  409.         data[n].x = TO_SCREEN_X(point->X);
  410.         data[n].y = TO_SCREEN_Y(point->Y);
  411.     );
  412.     XFillPolygon(Dpy, DrawingWindow, Output.fgGC,
  413.         data, Polygon->PointN, Complex, CoordModeOrigin);
  414. }
  415.  
  416. /* ---------------------------------------------------------------------------
  417.  * lowlevel routine to element arcs
  418.  */
  419. static void DrawArcLowLevel(ArcTypePtr Arc)
  420. {
  421.         /* angles have to be converted to X11 notation */
  422.     XSetLineAttributes(Dpy, Output.fgGC,
  423.         TO_SCREEN(Arc->Thickness), LineSolid, CapRound, JoinRound);
  424.     XDrawArc(Dpy, DrawingWindow, Output.fgGC,
  425.         TO_SCREEN_X(Arc->X -Arc->Width), TO_SCREEN_Y(Arc->Y -Arc->Height),
  426.         TO_SCREEN(2*Arc->Width), TO_SCREEN(2*Arc->Height),
  427.         (Arc->StartAngle +180) *64, Arc->Delta *64);
  428. }
  429.  
  430. /* ---------------------------------------------------------------------------
  431.  * draws the package of an element
  432.  */
  433. static void DrawElementPackageLowLevel(ElementTypePtr Element)
  434. {
  435.         /* draw lines, arcs, text and pins */
  436.     ELEMENTLINE_LOOP(Element, DrawLineLowLevel(line););
  437.     ARC_LOOP(Element, DrawArcLowLevel(arc););
  438. }
  439.  
  440. /* ---------------------------------------------------------------------------
  441.  * draw a via object
  442.  */
  443. void DrawVia(PinTypePtr Via)
  444. {
  445.     if (TEST_FLAG(SELECTEDFLAG, Via))
  446.         XSetForeground(Dpy, Output.fgGC, PCB->SelectedColor);
  447.     else
  448.         if (TEST_FLAG(FOUNDFLAG, Via))
  449.             XSetForeground(Dpy, Output.fgGC, PCB->ConnectedColor);
  450.         else
  451.             XSetForeground(Dpy, Output.fgGC, PCB->ViaColor);
  452.     DrawPinOrViaLowLevel(Via);
  453. }
  454.  
  455. /* ---------------------------------------------------------------------------
  456.  * draw a pin object
  457.  */
  458. void DrawPin(PinTypePtr Pin)
  459. {
  460.     if (TEST_FLAG(SELECTEDFLAG, Pin))
  461.         XSetForeground(Dpy, Output.fgGC, PCB->SelectedColor);
  462.     else
  463.         if (TEST_FLAG(FOUNDFLAG, Pin))
  464.             XSetForeground(Dpy, Output.fgGC, PCB->ConnectedColor);
  465.         else
  466.             XSetForeground(Dpy, Output.fgGC, PCB->PinColor);
  467.     DrawPinOrViaLowLevel(Pin);
  468. }
  469.  
  470. /* ---------------------------------------------------------------------------
  471.  * draws a line on a layer
  472.  */
  473. void DrawLine(LayerTypePtr Layer, LineTypePtr Line)
  474. {
  475.     if (TEST_FLAG(SELECTEDFLAG, Line))
  476.         XSetForeground(Dpy, Output.fgGC, PCB->SelectedColor);
  477.     else
  478.         if (TEST_FLAG(FOUNDFLAG, Line))
  479.             XSetForeground(Dpy, Output.fgGC, PCB->ConnectedColor);
  480.         else
  481.             XSetForeground(Dpy, Output.fgGC, Layer->Color);
  482.     DrawLineLowLevel(Line);
  483. }
  484.  
  485. /* ---------------------------------------------------------------------------
  486.  * draws a text on a layer
  487.  */
  488. void DrawText(LayerTypePtr Layer, TextTypePtr Text)
  489. {
  490.     if (TEST_FLAG(SELECTEDFLAG, Text))
  491.         XSetForeground(Dpy, Output.fgGC, PCB->SelectedColor);
  492.     else
  493.         XSetForeground(Dpy, Output.fgGC, Layer->Color);
  494.     DrawTextLowLevel(Text);
  495. }
  496.  
  497. /* ---------------------------------------------------------------------------
  498.  * draws a polygon on a layer
  499.  */
  500. void DrawPolygon(LayerTypePtr Layer, PolygonTypePtr Polygon)
  501. {
  502.     if (TEST_FLAG(SELECTEDFLAG, Polygon))
  503.         XSetForeground(Dpy, Output.fgGC, PCB->SelectedColor);
  504.     else
  505.         if (TEST_FLAG(FOUNDFLAG, Polygon))
  506.             XSetForeground(Dpy, Output.fgGC, PCB->ConnectedColor);
  507.         else
  508.             XSetForeground(Dpy, Output.fgGC, Layer->Color);
  509.     DrawPolygonLowLevel(Polygon);
  510. }
  511.  
  512. /* ---------------------------------------------------------------------------
  513.  * draws an element
  514.  */
  515. void DrawElement(ElementTypePtr Element)
  516. {
  517.         /* set color and draw lines, arcs, text and pins */
  518.     if (TEST_FLAG(SELECTEDFLAG, Element))
  519.         XSetForeground(Dpy, Output.fgGC, PCB->SelectedColor);
  520.     else
  521.         XSetForeground(Dpy, Output.fgGC, PCB->ElementColor);
  522.     DrawElementPackageLowLevel(Element);
  523.     DrawElementName(Element);
  524.     DrawElementPins(Element);
  525. } 
  526.  
  527. /* ---------------------------------------------------------------------------
  528.  * draws the name of an element
  529.  */
  530. void DrawElementName(ElementTypePtr Element)
  531. {
  532.     if (TEST_FLAG(SELECTEDFLAG, &ELEMENT_TEXT(PCB, Element)))
  533.         XSetForeground(Dpy, Output.fgGC, PCB->SelectedColor);
  534.     else
  535.         XSetForeground(Dpy, Output.fgGC, PCB->ElementColor);
  536.     DrawTextLowLevel(&ELEMENT_TEXT(PCB, Element));
  537. }
  538.  
  539. /* ---------------------------------------------------------------------------
  540.  * draws the package of an element
  541.  */
  542. void DrawElementPackage(ElementTypePtr Element)
  543. {
  544.         /* set color and draw lines, arcs, text and pins */
  545.     if (TEST_FLAG(SELECTEDFLAG, Element))
  546.         XSetForeground(Dpy, Output.fgGC, PCB->SelectedColor);
  547.     else
  548.         XSetForeground(Dpy, Output.fgGC, PCB->ElementColor);
  549.     DrawElementPackageLowLevel(Element);
  550. }
  551.  
  552. /* ---------------------------------------------------------------------------
  553.  * draw pins of an element
  554.  */
  555. void DrawElementPins(ElementTypePtr Element)
  556. {
  557.     PIN_LOOP(Element, DrawPin(pin););
  558. }
  559.  
  560. /* ---------------------------------------------------------------------------
  561.  * erase a via object
  562.  */
  563. void EraseVia(PinTypePtr Via)
  564. {
  565.     XSetForeground(Dpy, Output.fgGC, Settings.bgColor);
  566.     DrawPinOrViaLowLevel(Via);
  567. }
  568.  
  569. /* ---------------------------------------------------------------------------
  570.  * erase a pin object
  571.  */
  572. void ErasePin(PinTypePtr Pin)
  573. {
  574.     XSetForeground(Dpy, Output.fgGC, Settings.bgColor);
  575.     DrawPinOrViaLowLevel(Pin);
  576. }
  577.  
  578. /* ---------------------------------------------------------------------------
  579.  * erases a line on a layer
  580.  */
  581. void EraseLine(LineTypePtr Line)
  582. {
  583.     XSetForeground(Dpy, Output.fgGC, Settings.bgColor);
  584.     DrawLineLowLevel(Line);
  585. }
  586.  
  587. /* ---------------------------------------------------------------------------
  588.  * erases a text on a layer
  589.  */
  590. void EraseText(TextTypePtr Text)
  591. {
  592.     XSetForeground(Dpy, Output.fgGC, Settings.bgColor);
  593.     DrawTextLowLevel(Text);
  594. }
  595.  
  596. /* ---------------------------------------------------------------------------
  597.  * erases a polygon on a layer
  598.  */
  599. void ErasePolygon(PolygonTypePtr Polygon)
  600. {
  601.     XSetForeground(Dpy, Output.fgGC, Settings.bgColor);
  602.     DrawPolygonLowLevel(Polygon);
  603. }
  604.  
  605. /* ---------------------------------------------------------------------------
  606.  * erases an element
  607.  */
  608. void EraseElement(ElementTypePtr Element)
  609. {
  610.         /* set color and draw lines, arcs, text and pins */
  611.     XSetForeground(Dpy, Output.fgGC, Settings.bgColor);
  612.     ELEMENTLINE_LOOP(Element, DrawLineLowLevel(line););
  613.     ARC_LOOP(Element, DrawArcLowLevel(arc););
  614.     DrawTextLowLevel(&ELEMENT_TEXT(PCB, Element));
  615.     PIN_LOOP(Element, DrawPinOrViaLowLevel(pin););
  616. } 
  617.  
  618. /* ---------------------------------------------------------------------------
  619.  * erases the name of an element
  620.  */
  621. void EraseElementName(ElementTypePtr Element)
  622. {
  623.     XSetForeground(Dpy, Output.fgGC, Settings.bgColor);
  624.     DrawTextLowLevel(&ELEMENT_TEXT(PCB, Element));
  625. }
  626.  
  627. /* ---------------------------------------------------------------------------
  628.  * draws grid points if the distance is >= MIN_GRID_DISTANCE
  629.  */
  630. void DrawGrid(void)
  631. {
  632.     Position    minx, miny,
  633.                 maxx, maxy,
  634.                 x, y;
  635.  
  636.     if (TO_SCREEN(PCB->Grid) >= MIN_GRID_DISTANCE)
  637.     {
  638.         minx = TO_PCB_X(Output.OffsetX);
  639.         miny = TO_PCB_Y(Output.OffsetY);;
  640.         maxx = TO_PCB_X(Output.OffsetX +Output.Width);
  641.         maxy = TO_PCB_Y(Output.OffsetY +Output.Height);
  642.         maxx = MIN((Dimension) maxx, PCB->MaxWidth);
  643.         maxy = MIN((Dimension) maxy, PCB->MaxHeight);
  644.         for (y = miny; y <= maxy; y += PCB->Grid)
  645.             for (x = minx; x <= maxx; x += PCB->Grid)
  646.                 XDrawPoint(Dpy, Output.OutputWindow, Crosshair.AttachGC,
  647.                     TO_SCREEN_X(GRIDFIT_X(x)), TO_SCREEN_Y(GRIDFIT_Y(y)));
  648.     }
  649. }
  650.